﻿// 0804train03.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <limits.h>
#include <map>

using namespace std;


/*
 给定一个字符串，只包含字母和数字，按要求找出字符串中的最长 (连续)子串的长度，字符串本身是其最长的子串，子串要求:
1. 只包含1个字母(a~z,A~Z)，其余必须是数字
2. 字母可以在子串中的任意位置;
如果找不到满足要求的子串，如全是字母或全是数字，则返回-1。

输入
abC124ACb
输出
4
说明
满足条件的最长子串是C124或者124A，长度都是4
 */

bool IsCharacter(char oh_char)
{
    bool is_mini = oh_char >= 'a' && oh_char <= 'z';
    bool is_big = oh_char >= 'A' && oh_char <= 'Z';

    return is_mini || is_big;
}

void solve01(string&oh_str)
{
    int left_index = 0;
    int str_size = oh_str.size();

    bool is_target = false;
    for (auto&oh_char:oh_str)
    {
	    if (oh_char>='0'&&oh_char<='9')
	    {
            is_target = true;
            break;
	    }
    }
    if (!is_target)
    {
        cout << -1;
        return;
    }

    const int limit = 1;//只包含1个字母
    int target_count = 0;
    int result = 0;

    for (int right_index=0; right_index< str_size; right_index++)
    {
        char curr_char = oh_str[right_index];
        if (IsCharacter(curr_char))
        {
            target_count += 1;
        }

        while (target_count > limit)
        {
            char left_char = oh_str[left_index];
            if (IsCharacter(left_char))
            {
                target_count -= 1;
            }
            left_index++;
        }

        result = max(result, right_index - left_index + 1);
        //for------
    }


    cout << result;
    //solve01
}


/*
给定一个字符串的摘要算法，请输出给定字符串的摘要值
1. 去除字符串中非字母的符号
2. 对于去除非字母符号后的字符串：
  - 如果出现连续字符（不区分大小写），则输出: 该字母（小写) + 连续出现的次数
  - 如果是非连续的字符（不区分大小写），则输出: 该字母（小写）之后字符串中出现的该字符的次数
3. 对按照以上方式表示后的字符串进行排序：
字母和紧随的数字作为一组进行排序，数字大的在前，数字相同的则按字母进行排序，字母小的在前。

输入描述
一行字符串，长度为[1,200]

输出描述
转换后的摘要字符串

示例1
输入
aabbcc
输出
a2b2c2

示例2
输入
bAaAcBb
输出
a3b2b2c0
第一个b非连续字母，该字母之后字符串中还出现了2次 (最后的两个Bb) ，所以输出b2；
a连续出现3次，输出a3；
c非连续，该字母之后字符串再没有出现过c，输出c0；
Bb连续2次，输出b2。
对b2a3c0b2进行排序，最终输出a3b2b2c0。
 */
void update(vector<pair<char,int>>&result_vec, map<char, int>&oh_map, int left, int right, char right_char)
{
    int num_continue = right - left;

    if (num_continue==1)
    {
        result_vec.push_back(make_pair(right_char, oh_map[right_char]));
    }
    else
    {
        result_vec.push_back(make_pair(right_char, num_continue));
    }
    oh_map[right_char] += num_continue;
}

void solve02(string&origin_str)
{
    string oh_str;
    for (auto&oh_char: origin_str)
    {
        if (isalpha(oh_char))
        {
            oh_str += tolower(oh_char);
        }
    }

    vector<pair<char,int>>result_vec;
    map<char, int>oh_map;
    int str_size = oh_str.size();

    int right_index = str_size - 1;

    for (int left_index = str_size - 1; left_index >= 0; left_index--)
    {
        char left_char = oh_str[left_index];
        char right_char = oh_str[right_index];

        if (left_char != right_char)
        {
            update(result_vec, oh_map, left_index, right_index, right_char);
            right_index = left_index;
        }

        //for------
    }
    update(result_vec, oh_map, -1, right_index, oh_str[right_index]);

    sort(result_vec.begin(), result_vec.end(), [](pair<char, int>& a, pair<char, int>& b)
        {
            if (a.second==b.second)
            {
                return a.first < b.first;
            }
        //数字大的在前，数字相同的则按字母进行排序，字母小的在前
            return a.second > b.second;
        });

    string result_str;
    for (auto&item:result_vec)
    {
        stringstream oh_stream;
        oh_stream << item.first << item.second;

        result_str += oh_stream.str();
    }
    cout << result_str;
	//------
    //solve02
}


/*
 头和结尾都是元音字母（aeiouAEIOU）的字符串为元音字符串，其中混杂的非元音字母数量为其瑕疵度。比如:
- "a"，"aa"是元音字符串，其瑕疵度都为 0
- "aiur"不是元音字符串（结尾不是元音字符）
- "abira"是元音字符串，其瑕疵度为 2
给定一个字符串，请找出指定瑕疵度的最长元音字符子串，并输出其长度，如果找不到满足条件的元音字符子串，输出 0。
子串：字符串中任意个连续的字符组成的子序列称为该字符串的子串。
输入描述
首行输入是一个整数，表示预期的瑕疵度flaw，取值范围[0, 65535]。
接下来一行是一个仅由字符a-z和A-Z组成的字符串，字符串长度(0, 65535]。
输出描述
输出为一个整数，代表满足条件的元音字符子串的长度。

输入
0
asdbuiodevauufgh
输出
3
 */

bool IsTargetChar(unordered_set<char>&oh_set, char oh_char)
{
    return oh_set.count(oh_char);
    //IsTargetChar
}

void solve03(string&oh_str, int limit)
{
    unordered_set<char>oh_set;
    string target_str = "aeiouAEIOU";
    for (auto&oh_char:target_str)
    {
        oh_set.insert(oh_char);
    }

    int left_index = 0;
    int result = 0;
    int str_size = oh_str.size();

    if (limit==0)
    {
        int right_index = 0;
        while (right_index<str_size)
        {
            char curr_char = oh_str[right_index];
            if (!IsTargetChar(oh_set,curr_char))
            {
                //cout << right_index << '_' << left_index << endl;
                result = max(result, right_index - left_index);
                right_index += 1;
                left_index = right_index;
                continue;
            }
            right_index += 1;
        }
        cout << result;
        return;
    }

    int target_count = 0;
    for (int right_index=0; right_index<str_size; right_index++)
    {
        char curr_char = oh_str[right_index];
        if (!IsTargetChar(oh_set, curr_char))
        {
            target_count += 1;
        }

        while (target_count>limit)
        {
            char left_char = oh_str[left_index];
            if (!IsTargetChar(oh_set, left_char))
            {
                target_count -= 1;
            }
            left_index += 1;
        }
        if (target_count==limit)
        {
            result = max(result, right_index - left_index + 1);
        }
    }

    cout << result;
    //solve03
}


int main()
{
	{
        //1
        //aabeebuu
        //0
        //asdbuiodevauufgh
        //2
		//aeueo
        //int limit = 2;
        //string oh_str = "aeueo";
        int limit;
        cin >> limit;
        string oh_str;
        cin >> oh_str;
        solve03(oh_str, limit);
        return 0;
	}

	{
        //输入
        //bAaAcBb
        //输出
        //a3b2b2c0
        //string oh_str = "bAaAcBb";
        string oh_str;
        cin >> oh_str;
        solve02(oh_str);

        return 0;
	}

    //abC124ACb 4
    //string oh_str = "abC124ACb";
    string oh_str;
    cin >> oh_str;
    solve01(oh_str);
    //std::cout << "Hello World!\n";
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
